package com.power.service.impl;

import com.alibaba.nacos.common.utils.CollectionUtils;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.power.constant.ProductConstants;
import com.power.domain.ProdProp;
import com.power.domain.ProdPropValue;
import com.power.mapper.ProdPropMapper;
import com.power.mapper.ProdPropValueMapper;
import com.power.service.ProdPropService;
import com.power.service.ProdPropValueService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.util.List;
import java.util.stream.Collectors;

/**
* @author dingchunlin
* @description 针对表【prod_prop】的数据库操作Service实现
* @createDate 2024-07-10 15:12:13
*/
@Service
@CacheConfig(cacheNames = "com.power.service.ProdPropServiceImpl")
public class ProdPropServiceImpl extends ServiceImpl<ProdPropMapper, ProdProp> implements ProdPropService{

    @Autowired
    private ProdPropMapper prodPropMapper;

    @Autowired
    private ProdPropValueMapper prodPropValueMapper;

    @Autowired
    private ProdPropValueService prodPropValueService;

    /**
     * 分页查询产品规格
     * @param current  当前页
     * @param size     每页显示数量
     * @param propName 规格名称
     * @return 分页数据
     */
    @Override
    public Page<ProdProp> queryProdSpecPage(Long current, Long size, String propName) {
        // 创建分页对象
        Page<ProdProp> page = new Page<>(current, size);
        // 设置查询条件
        LambdaQueryWrapper<ProdProp> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.like(StringUtils.hasText(propName), ProdProp::getPropName, propName);
        // 执行查询
        page = prodPropMapper.selectPage(page, lambdaQueryWrapper);
        // 将分页的数据进行处理
        List<ProdProp> prodPropList = page.getRecords();
        // 判断是否为空
        if (CollectionUtils.isEmpty(prodPropList) || prodPropList.size() == 0){
            return page;
        }
        //从属性对象中获取属性id集合
        List<Long> propIdList = prodPropList.stream().map(ProdProp::getPropId).collect(Collectors.toList());
        // 属性id集合查询属性对象集合
        List<ProdPropValue> prodPropValueList = prodPropValueMapper.selectList(new LambdaQueryWrapper<ProdPropValue>()
                .in(ProdPropValue::getPropId, propIdList));
        // 遍历属性对象集合，将属性值添加到属性对象中
        prodPropList.forEach(prodProp -> {
            prodProp.setProdPropValues(prodPropValueList.stream()
                   .filter(propValue -> propValue.getPropId().equals(prodProp.getPropId()))
                   .collect(Collectors.toList()));
        });
        return page;
    }

    /**
     * 保存产品规格
     * @param prodProp 产品规格
     * @return true/false
     */
    @Override
    @CacheEvict(key = ProductConstants.PROD_PROP_LIST_KEY)
    @Transactional(rollbackFor = Exception.class)
    public Boolean saveProdSpec(ProdProp prodProp) {
        // 新增商品属性
        prodProp.setShopId(1L);
        prodProp.setRule(2);
        int insert = prodPropMapper.insert(prodProp);
        // 新增商品属性值
        if (insert > 0){
            // 获取属性的id
            Long propId = prodProp.getPropId();
            // 添加商品属性对象与属性值的关系
            List<ProdPropValue> prodPropValueList = prodProp.getProdPropValues();
            // 判断属性值是否为空
            if (CollectionUtils.isNotEmpty(prodPropValueList)  && prodPropValueList.size() > 0 ){
                prodPropValueList.forEach( prodPropValue -> prodPropValue.setPropId(propId));
                prodPropValueService.saveBatch(prodPropValueList);
            }
        }
        return insert > 0;
    }

    /**
     * 修改产品规格
     * @param prodProp 产品规格
     * @return true/false
     */
    @Override
    @CacheEvict(key = ProductConstants.PROD_PROP_LIST_KEY)
    @Transactional(rollbackFor = Exception.class)
    public Boolean modifyProdSpec(ProdProp prodProp) {
        // 获取原属性值集合
        Long propId = prodProp.getPropId();
        List<ProdPropValue> dbProdValue = prodPropValueMapper.selectList(new LambdaQueryWrapper<ProdPropValue>()
                .eq(ProdPropValue::getPropId, propId));
        // 获取新增属性值集合
        List<ProdPropValue> prodPropValueList = prodProp.getProdPropValues();
        boolean flag = false;
        //判断属性是否进行了删除
        if (dbProdValue.size() == prodPropValueList.size()){
            // 只是进行了修改
            // 批量修改属性值对象
            flag = prodPropValueService.updateBatchById(prodPropValueList);
        }else {
            // 进行了删除或新增
            // 删除原来的属性值对象
            prodPropValueMapper.delete(new LambdaQueryWrapper<ProdPropValue>()
                    .eq(ProdPropValue::getPropId, propId));
            // 批量新增属性值对象
            prodPropValueList.forEach( prodPropValue -> {
                prodPropValue.setPropId(propId);
                prodPropValue.setValueId(null);
            });
            prodPropValueService.saveBatch(prodPropValueList);
            flag = true;
        }
        // 修改商品属性
        if (flag){
            prodPropMapper.updateById(prodProp);
        }
        return flag;
    }

    /**
     * 删除产品规格
     *
     * @param id 产品规格id
     * @return true/false
     */
    @Override
    @CacheEvict(key = ProductConstants.PROD_PROP_LIST_KEY)
    @Transactional(rollbackFor = Exception.class)
    public Boolean removeProdSpecByProdId(Long id) {
        // 删除商品属性值
        prodPropValueService.remove(new LambdaQueryWrapper<ProdPropValue>()
                .eq(ProdPropValue::getPropId, id));
        return prodPropMapper.deleteById(id) > 0;
    }

    /**
     * 查询产品规格列表
     * @return 产品规格列表
     */
    @Override
    @Cacheable(key = ProductConstants.PROD_PROP_LIST_KEY)
    public List<ProdProp> queryProdPropList() {
        return prodPropMapper.selectList(null);
    }

}




